/**
  * Created by lilei on 2016/11/16.
  * 测试IO
  */
private class TesstScla (name:String,age:Int) {
//    --val 用在class的参数中，表示既是参数，又是属性
//    class Person(name: String)   --name是私有的
//    class Person(val name: String)  --name是公共的，外部可以访问
//scala中也有abstract，抽象类，和java一样，它和trait不一样，可继承多个trait，并且抽象类不能实例化

    override def toString = getClass.getName + "[name=" + name + "]"

}
object TesstScla  {

    def getNameAndAge{
      println ("12"+ new TesstScla("lilei",12))
      println (12)
    }
    var a = s"1234"

    def main(args : Array[String]) {
        println(TesstScla getNameAndAge)// 单例函数调用，省略了.(点)符号

//
//        val writer = new PrintWriter(new File("C:/test.txt" ))
//
//        writer.write("菜鸟教程")
//        writer.close()
        println(a)
        var list1 = List(1,2)
        var it = Iterator(1,2)
        println(it.next)
        val it2 = Iterator("Baidu", "Google", "Runoob", "Taobao")

        while (it2.hasNext){
            println(it2.next())
        }

        var li =List(1,2,3,4)
        for(x <- li if x > 2;if x > 3){//带条件过滤,且多条件
            println(x)
        }

        var test1 = for{
            y <- li
//            k <- li
            if y > 2
//            if k < 4
        } yield y
        println("-----------------")
        def test2(k :Int) = {
            println(k*2)
        }
        for{//yield使用时的格式for后直接大括号
            y <- li
            //            k <- li
            if y > 2
        //            if k < 4
        } yield test2(y) //这里不能是匿名函数
        val pattern = "scala".r //正则示例，另外无参数的方法可以省略括号
        pattern.findAllIn("scala hello wolrd")
    //test23方法定义在class里，是实例方法，以此可以比较object实现的static效果
        var instance = new TesstScla("", 2)
        instance.test23

 oncePerSecond(tr)
        println(apply(layout, 10) )
        //scala所谓的高阶函数，其实就是函数使用其他函数作为参数，或者使用函数作为输出结果
        //这里只是函数名被引用，而非函数发生调用，注意和函数调用的区别
        //传名调用：则传的是函数调用，即a()，而不是函数名
        //所以匿名函数不能作为参数传递，无参的好像可以，其他都不能
        var value = JSON.parseFull("")
         value.foreach{//这里一个case相当于一个匿名函数，在scala里叫偏函数，对于该匿名函数的要求是只允许有一个参数
            case l:List[Any] =>
            case m:Map[Any] =>
            case _ => print()
        }
    }

 lazy val t:T = expr 无论expr是什么东西，字面量也好，方法调用也好。Scala的编译器都会把这个expr包在一个方法中，并且生成一个flag来决定只在t第一次被访问时才调用该方法。
def oncePerSecond(callback: ()=> Unit): Unit = {
        while (true){
           callback()
            Thread.sleep(1000)
        }
    }
    def tr(): Unit = {
        println("pp")
    }

    def apply(f: Int=> String, v: Int) = f(v)//Int是参数类型，String是返回类型，其实传入apply里的函数要符合这种格式

    def layout(x:Int) = "[" + x.toString() + "]"



}



 //定义类的时候，就定义了构造器。即：是（）内的内容。  
    //主构造器会将类定义{}里的所有语句执行一次。  
    //如果主构造器参数不带val或var，那么会根据是否被方法使用来决定。  
    //如果不带val或var的参数被方法使用了，它会变为对象私有字段；  
    //如果没有被方法使用，则被当成一个普通的参数，不升级成字段。  
    //这里的主构造器是(pname: String, page: Int).  
    class Person(val pname: String, page: Int) {  
  
        println("start...")  
  
        var name = pname  
        var age = page  
        var message = ""  
  
        //从构造器，调用主构造器。  
        //规则：每一个从构造器的第一个动作都是调用同一个类里面其他的构造器!!!!因此主构造器是类的唯一入口点。   
        //这里的从构造器，调用了主构造器。  
        def this(pname: String) = this(pname, 20)  
  
        //同时加入其他逻辑  
        def this(page: Int) {  
            this("mike", page)  
            message = "hello"  
        }  
  
        println("end...")  
    }